{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-2-9175512a5133>:2: read_data_sets (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "WARNING:tensorflow:From /home/kite/anaconda3/lib/python3.7/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:260: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please write your own downloading logic.\n",
      "WARNING:tensorflow:From /home/kite/anaconda3/lib/python3.7/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:262: extract_images (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./train-images-idx3-ubyte.gz\n",
      "WARNING:tensorflow:From /home/kite/anaconda3/lib/python3.7/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:267: extract_labels (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting ./train-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From /home/kite/anaconda3/lib/python3.7/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:110: dense_to_one_hot (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.one_hot on tensors.\n",
      "Extracting ./t10k-images-idx3-ubyte.gz\n",
      "Extracting ./t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From /home/kite/anaconda3/lib/python3.7/site-packages/tensorflow/contrib/learn/python/learn/datasets/mnist.py:290: DataSet.__init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "(55000, 784)\n",
      "(55000, 10)\n",
      "(5000, 784)\n",
      "(5000, 10)\n",
      "(10000, 784)\n",
      "(10000, 10)\n"
     ]
    }
   ],
   "source": [
    "dir = \"./\"\n",
    "mnist = input_data.read_data_sets(dir, one_hot=True)\n",
    "\n",
    "print(mnist.train.images.shape)\n",
    "print(mnist.train.labels.shape)\n",
    "\n",
    "print(mnist.validation.images.shape)\n",
    "print(mnist.validation.labels.shape)\n",
    "\n",
    "print(mnist.test.images.shape)\n",
    "print(mnist.test.labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAd0AAAHiCAYAAACtERYWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3Xd81EX6wPFnUggloStKr6Ep5RR7QQELYu8N9VAUbJyKenr+PM5T76yA2Cgq9nqo2LCCDQURpUgv0kF6D0l2fn8kzHxnzYbNZnc25fN+vXzdM5nZ3Tm+2Tz7ndmZUVprAQAAiZeS7A4AAFBZkHQBAPCEpAsAgCckXQAAPCHpAgDgCUkXAABPSLoAAHhC0g1QSmml1A6l1P1Rtu+nlNpe+LjWie4fSobrWbHEcD2HFLbXSqm0RPcPJVcZ36OKzTEspZQWkTZa64WF5WNF5OOwZjVE5Dyt9TuRHoeyoYjrWV9E3hORdiKSKiJzROQ2rfV3xT0OZUNx10UpdYWIvCAi12itRwd+3lxElohIutY6z09PEa2irqlSKlVEhojIX0UkS0QWisgJWuvNxT2uvODTXzG01t+ISObeslKqu4iMF5FPktUnlMp2KXgjLxARLSJnish4pdT+/EEuv5RSdUTk7yIyO9l9QVwMEZGjRORIEVkmIh1FZHdSexRHDC+XzBUi8rbWekeyO4KS01rv1lrP01qHRESJSL6I1BGRusntGUrpQREZLiLrk90RlE7hB6hBUjBi8bsuMEtrTdKtbJRS1UXkPBEZm+y+oHSUUjOk4JPz+yIyWmu9LsldQoyUUoeJyKEi8kyy+4K4OFhE8kTkPKXUGqXUfKXU9cnuVDwxvBy9c6Xgk/SkZHcEpaO17qSUqioiZ4tIlWT3B7EpnPt7SkRu1FqHlFLJ7hJKr7GI1BKRbBFpISJtROQLpdR8rfVnSe1ZnHCnG70rRORFzTfPKoTCoebXROROpVTnZPcHMRkoIjO01pOT3RHEza7C//2X1nqX1nqGiLwuIr2T2Ke4IulGQSnVRES6i8iLSe4K4i9dRFomuxOISQ8RObtwGHKNFHz55lGl1Igk9wuxm1H4vxX25obh5ehcLiLfa60XJbsjiJ1S6ggp+J2fIgVLhm4SkQYi8mMy+4WYXSkiVQPl/4nI2yIyJim9QalprRcppb4RkbuVUjdJwQfiC0Xk4uT2LH5IutHpKyIPJ7sTKLUMKfiWa0sRyRWRmSJymtZ6VVJ7hZgE122KiCil9ojIVq31liR1CfFxsRR8cNogIutE5B6t9RfJ7VL8MLzsyhGRaUqp+4I/1Fq301r/6dOzUuoqpdTmwseFPPUR0XOup9Z6kta6s9Y6S2tdV2t9vNb6672NuZ5lXpHvz7201t3DNsa4V0R+LXxchR2uLOf+dE211iu11qdorTO11i211s/urasI71F2pAIAwBPudAEA8ISkCwCAJyRdAAA88frt5V4p5zOBnCSfhd6K+3Y9XM/kScT1FOGaJhPv0Yol0vXkThcAAE9IugAAeELSBQDAE5IuAACekHQBAPCEpAsAgCckXQAAPCHpAgDgCUf7AQDKvpRUE84f1dWpmn3yUyY+/YoBJk77Ylri+1VC3OkCAOAJSRcAAE9IugAAeMKcLgCgzElr1sQpz3+wnomXdB8d1rqKiTa3snH9LxLStVLhThcAAE9IugAAeMLwMiqN1A7ZJp47oI5Tt+Ccp00cEvcI0hSxx2I+tbmFicc+1ttpV2/M5Lj0E6is0lo2N/Fvd9d36v48pGxds/xoEzf4Zr2J8+PXtbjhThcAAE9IugAAeMLwMiqUtCaNnfJv9x5g4tdOfNbEXTNCTrtQ4PNnSNy64GfT/rUXmrjhHa84rZ6bcKyJ81asjL7T+JOUqlVN3PRr5dQ91eg7E6cqe23m7NnptLv15L4mzp+3UFA2qXT7beM5/6xr4iU9Iw8nt/z8r065bf/fTBzavSCOvYs/7nQBAPCEpAsAgCckXQAAPKn0c7qrbznKKavAapGqG2xhUzv3cQdOtl9Grzp+SkL6hugsfuhIE8+99EmnLrj8J7j0JxT2efPDnbVMPGV7y4ivdUiNpSY+N3OrU7dqwiwTf9DRXZKEfQvO46583S7N+qDRK0U1FxGR7rPOMrF61F1ikrHol1L3Ka15UxPnLV1W6ufDn80b0dnES3qOitiu9cQrTdym789OXfi3MMoy7nQBAPCEpAsAgCdlcnh53fXukO/mTrkmHnfSiLi+VvsqUyPW7dZ5Jq6VUs2pW3f5DhOvGu7+Mz62ppeJN1xQ08R5y1fE3E9Edn4vu4QkfDcpd/mP/Yz55OZWTrvPTu5o4uKW+3x3+kUmPuOZp5264HKiD6Rb8Z3Gnyz8pz2YfG63JyO2a/PF1SZuO2CeiUM7ljrt3N+E6Mwf6V639056wsQXvnCLU9f0n9/H8ApYOPQIt9znqUDJvkdbfuYuC8ruP9vEsVzbsoI7XQAAPCHpAgDgCUkXAABPysyc7vxRdi5lbu9hTl2GSg+WPPUo/HVd+6fWCMRu3YvNvjbxZW90N/GmS5o67ViCUAqHHWzC6+rZudUPdx7gNAsu/5m1taGJcwbv57Rb9JC9iNn3VXfq8ufYbeWCy8PSn3UvfG5gomnlHe73Ehr9l/m/cPrIzk7560seDpTsNViW527vmN3PLs0K5e4pdT9yex5i4nG93O+MdAxsUYjY7TnF/n0fd9ZQpy5V2aVizrKgq3512ulQWTwzqOS40wUAwBOSLgAAnpSZ4eWnT3jRxOHDuv/d0MbE6/ZkxfT8/5tmh5CajlfFtIzOih7288pDvV916oI7Fb3cfKKJL3u1u9Nu04X2RByWE5XQlJkm7H/uABOnrt7oNHOX/6wx0co73F2n5hxvl4acOuoapy51jo039LO7X+XqaU674PKkZq/87vYjvP+QtXe4Q8P7p9oh5V3a1vUddKvTrnruj3Htx/a/2ffrwVXcvz3bdY6JW7y1wamrGIOdftS7e4mJO1Wp6tT1mnO6ibPvtdciv4IMJ4fjThcAAE9IugAAeFJmhpeHXnieif/RpaZTt/+7dteZ/A3u8GG0siXyzlOxaD3exqOf6+3UrXnd7pB0fe3lJg4ONYuItO1vh0Wb38Pwcqz0VDvUHO0wbtX17p42I7c0N3GVtdudusVD7DeRX7jcDkMHD1AQEZmWYz/Dcoj9vvXP/jZi3dnzzjdx9XGRh5NVmv0TpqpVi9guXP7Bdnrh8fbPR2zXfdpVJt5/9tyonx+umxp9HrFu61g7zVZ7wWQf3Ukq7nQBAPCEpAsAgCckXQAAPCkzc7p6mj1Bop67EqPMfzU/NMOd63n+8T4mvn7I0+HNjVcvsztv3XXPYfHvWCW060z333FjO/srHpzHrTfTnbftX2upibt84C73OSzDPi64LGhqjvuZ9R/97FKjVHEP2UbJZKXvNvGOsLrckw41cd17lpr4jZafluAVJhX50+/Crul+//G3A15Fs+Uye5rQcVV/MfHRM85x2tV+6QdvfSoLuNMFAMATki4AAJ6UmeFlIB5WXejucjTneDu8H1ziE37YfbAuOJwcXhdcFnT52zc47Vp+VfGXO8TTyFGnO+XrbrOHDbzY0q7Ju+77U5x2Y5rZa5omYaeNlNKV469zym0mV66hz3jafEb4xECBne+7h5Jk6sWJ60RK2O9HGdjlijtdAAA8IekCAOAJw8txsOIu9+zUUNdtUT2uQaodCs078RCnLu3LaeHNEYPgt42DnzHdnxdf13/5iSZe/nd7+AbDyaWzo3H4NbCqKXuO7dhmX4bV2iHDW9fYb6t/NKGb0yr3QPv+WnjSqKj6VP/n0h+GggIH1tla5M+rbYh83WOVc6q99uuvsecvH9RgtdNu23n29ypv9RpJBu50AQDwhKQLAIAnJF0AADyp9HO6aS2bO+WF/Q408VMXjYzqObpXdXcfSlXRfZZpnJZp4pHPD3PqBjY7JqrngKvhG1Wc8vmN7LKUg2quMvF19b532jUKHKAe/ll00YPtTVztqylx6CVERLKf/cMpt8+9PqrHtX7JnjQWmrfIxC3y3Dn2xf85MqrnG7jyaBPXfdX9LoUOb4yI0g5o4JRHtX0lUMqU0kqtXcvEZ01e4NRdmDXcxLVSIp821XHEpSZufC5zugAAVGgkXQAAPKk0w8vbzz/cxH/8xX7W+Nc5rzvtLsraFMOzl/6zS8/PBznlbPmp1M9ZGVV7zx3+zXnPxtMC16l/twFOu2332d1zvjz4DafumH/aXYl+ndbExBxUXzr58xc55RZ3LorQMuxxUT5/2s7olv/8NLqLievnsgwsZunpTrFpWumGlNcNdJdinnXtRBP3r7UqrHXkIeWg/bKK3iXLJ+50AQDwhKQLAIAnJF0AADypUHO6qmtHE9ce4W7/9VFzezJJtEt63t1h5yRm7Wocsd0HD3V3yqk5dqHBFf+yp6X8eR7CqrImPWJdZZHWxP03zlu+ImGvpafOdMqZgYNszp/knn4zrvVHJj7oaruUq+k/mdMty1Qxk795gZnhOvNzPPSm4tPb3O1vR25paOLi/val1q9n4uV/bWvimYOeimPvCmzZVdXE+8f92aPDnS4AAJ6QdAEA8KRcDy//PsT9Svk9F9mlHpdmbXDqluXZkyfm7qlj4htfu9ppV321XWZw4MT1Js7/bX7EftSSyAddL/h7YJeWsCGWJbnbTdz8ve1SGe06054SE1yaIyLywe92uuDAs+Z469OWR5o65dAzdrogt80ub/1A6Vx18YSIdecvtFMIqRN/jtgO0cvfvMUpv7bCnvzTv5Zdu3f0HT867brdZw+xvyDzi7j2acgfHZxyw5vskqG8uL5S9LjTBQDAE5IuAACelOvh5drd1jnl4JByj9/OcOpynzjAxMFdi5pL5B1oot35Jlzo+K4mPqv2mECN+xlnYyiwOf8U99u0FVnwW8oXPvixiX/a2txp53NIObiZ+nn/cYclU4SDzcuD1P32c8ptMhZGbLv+6eYmzpLkbHxf0e1+3h4ek/NwrokfPmB63F8rV9u/1h0m9TNx9t/daca835fH/bVLijtdAAA8IekCAOAJSRcAAE/K9ZxuvX7uMpvWt9iTY1oNdudq02SZlz6JiGzKtrueHF018uea/rMuM3F9ibwkqaL5/RK7JCe4lODx6T2ddq0k/nM/xmEHO8VTn//a9qm2OxcYCnw2TZ8f3Wkm8G/LCa2c8unV7dz8du3uOlV1fa4gsWq+apcA/vhvu+PecVWLar1v+Tpk4kN/usSpq/K2XQba8iX7tz9Zy4KKw50uAACekHQBAPCkXA8v5612v+rfanDZ+Or/hm5FD2rM2bPTKWc9VavIdhVdo6/sxujpN6ea+OYuXzrtxtx4monrzXaHB9O+nFbkc6d2yHbKq3rUN3Hmafb346uDX3DaBZcFhcI+i2Z/fK2Nh3xf5Osi+a4Y8n7EuiW57jVN/7zo3x/41+7by02sZmWZuMXw2U47nW+Hl/ffNjfxHUsQ7nQBAPCEpAsAgCckXQAAPCnXc7plxcmztjrlcbWfDJTsVo9XzL7CaVfn46mJ7FbZFdjy8ugZ55j4y4PfcJpdd+cTJg5JyKkbsu6QIp/6jFqvOeWuGfZxKYHPmOHPF/z82fbt652aDg/brePK4hIEFKiXGvmkrkdWnxz2k82J7Qwi6vD0QKfc/EG7La/Os++wWLfhLeu40wUAwBOSLgAAnjC8HAfn1ZzhlKunZJp4fq49NLn6iNre+lRe1L5mj4mHvO8OGT/QwP675mqnSu7b/xcTh8RWhp8IFFz+szbfHkD/1IajnHafjjjaxG3GuLuZMaRc/u0Jpe67ERLm/pZdTNxE3GV3OrxxBcedLgAAnpB0AQDwhOHlGK0baIcnG6S630Jekmu/RXnxA4NNXP9jd9gSInnLV5j419ObOHWt/1v0N5RFROZ0H23i42ZcYOI/NtaM+JjWQ+1AsZ4606mrJ1ybimxU8w+c8iGP/s3ErW79Ibw5kDDc6QIA4AlJFwAAT0i6AAB4wpxulFRGhlM+9zp7Is620B6nrveUASZu+ixzhdHKW7HSKbe6dGWEliJ9xM731pRFgTiyyrY0obK5+/VLnXK7vo/ZON19/0rIXVoG+MKdLgAAnpB0AQDwhOHlaIXcwcmXxp9g4o9/7e7UNX2TJQiAb83+z53KueX/jozYthVLxJAk3OkCAOAJSRcAAE9IugAAeMKcbpR0rrssqPndzAkBAEqGO10AADwh6QIA4InSmn16AADwgTtdAAA8IekCAOAJSRcAAE9IugAAeELSDVBKaaXUDqXU/VG276eU2l74uNaJ7h9KJobr2bPweoaUUj0T3T+UDO/PiieGazqksL1WSpXLfSZIun/WWWt9996CUmqkUmpe4R/iK4MNtdZjtNaZ3nuIkgi/nicqpX5WSm1VSi1WSvXfW6e1/rzwei5LSk8RDd6fFU/4Ne2ilJqmlNpZ+L9d9tZpre8VkY5J6WWckHT37VcRGSgiPye7IygdpVS6iIwTkWdFpJaIXCgijymlOie1YygN3p8ViFKqioi8JyIvi0gdERkrIu8V/rxCIOnug9b6Sa31FyKyO9l9QanVFZGaIvKSLjBVROaISIfkdgux4v1Z4XSXgu2Jh2qtc7TWw0VEiciJSe1VHJF0UWlordeKyGsicpVSKlUpdaSINBORb5PbMwCFOorIDO3u2jRDyvmQclC5nIgGSuE1ERktIsMKywO01suT2B8AVqaIbAn72RYRyUpCXxKCO11UGkqpdiLyhoj0FZEqUvDp+Xal1GlJ7RiAvbZLwRRQUE0R2ZaEviQESReVyUEiMk9rPUFrHdJazxORD0Xk1CT3C0CB2SLSSSmlAj/rVPjzCoGkuw9KqSpKqapSMJmfrpSqqpTi3618mi4ibQqXDSmlVCsR6SMF34BFOcT7s8KZKCL5InKTUipDKXVD4c+/TF6X4otfzn37VER2ichRIjKyMD4uqT1CTLTWi0TkryIyXES2isgkEXlHRMYks18oFd6fFYjWeo+InCUFU0CbpeD9elbhzysEkq4rR0SmKaXu2/sDrXV3rbUK+2+iiIhS6iql1ObCx4WS02UUo6jr+abW+iCtdZbWurHW+g6tdUhERCnVo/B6NpCCT9soW3h/VjxFXdPpWutDtNbVtNZ/0VpP31unlLpXCkamckSkXJ5Ly3m6AAB4wp0uAACekHQBAPDE6+YYvVLOZyw7ST4LvaX23apkuJ7Jk4jrKcI1TSbeoxVLpOvJnS4AAJ6QdAEA8ISkCwCAJyRdAAA8IekCAOAJSRcAAE9IugAAeELSBQDAE5IuAACekHQBAPCEpAsAgCckXQAAPCHpAgDgiddThsqzJa93csrfHv20iS/pe6NTl/rVz176BCCyRY8eYeKbT/nYqfvo4iNNHJox11ufsA9H2L+zS252D+mZf/xYE7eeeKVT1+qSXxLarXjiThcAAE9IugAAeMLwcpT0shpOud6x1Uy8sW2GU7ffV166hDjKOa2biTdes92pm97tlaie47oVx5r42487O3Utn11s4rzVa2LpIvYhrVFDpzzizOdN3KvaLqdu7OG9TVxvRmL7heKtGXSUiR+44TkTn1Rth9MuV9t42GGvO3XDpV2Rz732xqOccsNX7VRC/oaNJe5rPHCnCwCAJyRdAAA8YXg5SjVWqIh1B1z4u1POfybRvUEsVHoVE89/rKtT9+Hpj5u4dbo7XRCK8vmfafyNfcw1Xzt1XQ7ua+LG5zK8nAiLrm3mlMOHlJE8KsO+pzZd8Ben7uvbHjVxdVVFSmvF3+2Q8tTrhzp1b17f2MTDh57r1O33zORSv3Y0uNMFAMATki4AAJ6QdAEA8IQ53TjYlZfulEs/K4FEmPdEFxPPP/0ppy5Fqpo4JFqi0X95d6c8usmkiG2Hd7FLHB6td7yJk7VsoSJqcvSKZHcBESz+p53Hnd13RFhtdH8xn9nc0sTPvnSaU9dIvjdxTj37LYx0leq0uzRrtYm73fmYU3e53GLiRM7vcqcLAIAnJF0AADxheDlKNU9bHbFuyzvuTjj7ye8RWiLRgsuCRNwh5dl9gsNa7rDT6vydJj5u3G1OXctxe0ycscAu98lfv8Fp1/WNS008rdvLTt3Pu5qbWO/JjdB7lNTuPoeZeFjLJ8Jq0wXJE1wmVKPDphI//uOdWU75ndtPMnGjD78Pb15i2WF/K17/+yMmPrnrINvu2qmlfq0g7nQBAPCEpAsAgCckXQAAPGFOtxj53e3X3Md3fNKp+2WPnRNs8Mospy7abQMRf6uvP9Qpzz89OM9nr9mYLU2ddv+7ppeJ23z3Q8TnzyvmtXNyIs8hjl9pD+eutm1JMc+CkthVz17Tg6swh5tMKs1NJ4v+Zf9+/nZo+DKhogWX4a07153TzVgZ3dxq8w/tdzA6NbvSqZt25BgThy8napFmlw3WnJu43yXudAEA8ISkCwCAJwwvFyM/w34myVTuyTO52u5aFNq2zVufULwB/d9zyiliT4d6cEMHE08+I9tpp5b+EtXzp9asaeIVVx/k1N3e6X8mnr7HnWSodjJDysn0XY57f5G1vLiJAsQip6d7ctdvl0U3pHzzqqNNvPY0O6ybv2FVTP1I/epnEzf9yq0bN+9AE1+QuS6m5y8t7nQBAPCEpAsAgCcMLxdj6dl8Jilv8sM+RwYPL/joge4mzloa+RvKkuJ+qzH/+M4m7jPiCxNfV9sduwoOZZ8276ywJ10Z+fUQs3bXzY6q3dAVvZxylU/iu8tQZbX2Jntg/MAB70b1mOBwsojIkuPteza0s+IfAEJWAQDAE5IuAACekHQBAPCEOd1iZB3AUqCKpPqaPftuJO4crojIxy+PiupxZy/sbeKUc3c6dflRPQNKamCD4Ly6ithu3sdtnHJj+SNBParYUjq3d8r/ucnu8NSj2s7w5kZwp6ngsiCRxM7jqq4dnXLz9J8jtBRZmJtj4lqLE7ekjDtdAAA8IekCAOAJw8uoUBbsauD+oNZSEz734nAT/2dtT6fZxN9bm/iTw4aLq5qJtoR2m7jbh39zWrW71S5fCe3YEW2X4UGzd93hZIb7Y3PsS+7wbHFDykFT3z3YxI02lP4A+mjNG1DdKR+WoSO0FJmww+5YV+29KQnrE3e6AAB4QtIFAMAThpfDpFS1Zyoe0yjyJvWj1h0fKG1PYI9QEnOu7+D+4J0fTXhgqh0mHtbwO6dZSkM75BUKDCeHO+GJwSbOfsgdJuMcZT+CuyC1TQ9eg6pOu5X5gaHPPAaUY7X+2iNNPKDOo2G19iCY1fm7nJpbfre7sjX931oTJ/pKpLVoZuJJpzweVhv5vf3txtaB0vr4diqAO10AADwh6QIA4AlJFwAAT5jTDZNSu5aJn2j4ccR2k761B5i3kmJOrEHC5ZzWzcTLL3J3kkkpZpeioFQV+Pyp3dnZHrPPMXHDh/wtd0CB1Ab7O+Wul8w0cc2UquHNje7jbjNxmwW8R2O1zU6RSmZKRsR2j6w7wX3cscF50cTNkYabd709qD74PY5wmwLL/0RE1gxrZeIazOkCAFD+kXQBAPCE4eUwec0b7LuRiDT9JDfBPUFQSqd2TvmAkfZQ+NFNnjVx8ND6gnLR7lzTzSn/b8qhJn6611inbkzbl03c9wI7ZJn5JkOWXtSv4xRHN/mkyGZbw4YLs5ZwT+HTJ58f6pRbyGR/L67sNJJOje4ht6041SnXePvHCC3ji99KAAA8IekCAOAJSRcAAE+Y0w2z/u7dRf6899wznHKVib+aOPK5FSiN9f3t9nMT7nnEqavlLBWJvCzo1tVHmPjjL+2cU/bj7haf2avtqSKPnHCpUxc8xP6ie+0ysg/edOcakRj5NapE1W5mrnuizAFDWd7l04HfJW+rzS2XHm7iuRc8GdVjvv/O3TLW19JP7nQBAPCEpAsAgCcML4d5+qBXAiX73fNVW2s67RrmrfDUo8pj20VHOOXgkHKtsJ2H5uTaJVuPr+ll4nlDOzrtar37i4lb7rZLGNx9q1ypk351yu3evN7Ev54/1MTjTrrBaZf+6U/FPCtilfXo6qjaDZjuTgs0ltmJ6A4iaHbXXKe8dnx8nz+tcSMTL7i+qVP342XB048i75r12ja7JDT7+U1Ona/Bce50AQDwhKQLAIAnlX54Oa25O0yRpew3HlNVuu/uVGrrO7nfQg4OKY/bUdepe/6C00wc+uU3E2eFfQMxloPlU6q5Q9kd/7LUxBmB34lQWnSHKaDk0po0NnF25rKI7S5d2tPEza5e5dRxbL1fx9Re6JTfbWOni/IXLI7qOVLbtzHxgivqO3VDz3vexCdV2xH2yMhDykFjrz/TxGmzp0X1mHjjThcAAE9IugAAeELSBQDAk0o/p7t7tFvOTrfzefmBw8wz33SXDCHxggfQ3/HVBU5d9i9T4/paqfXrmbj6OHeu9o2WHwVKzOP6sKZ3ExO/v//7Tl2qsvcKm3bbXahS9rhLQFS63clK5+6JdxcrjTaj7ZKtIb27OHX37meX5F1Vc7lTl/q+/fs5c2djiUaXGpNMfGlWdEvFwr2/w+4Ud9vnFzl17X6wy8hi+b5HPHCnCwCAJyRdAAA8qZTDy6nZrUx8a/P3I7a7eInd6ajm634OOK7M6s9wj47YFNpl4qm9hzp13Z4dZOL2//e7ifPXrov4/GmNGpp4R+dGTt2gYa+Z+LTqW5y64DDUk5vt7061b+ZGbIfECU77fNQu8P6d77Zr8/ZAG9/sZzP7iihv8VITTxh+jFM3aIj9dw3fNa5vzZW2EIzjYKd2pwue3GiHvb/+azcTZ/80xWlXFt6j3OkCAOAJSRcAAE9IugAAeFIp53T3NKpl4h7VciK2m/9GWxM30ByInWhZr7vzbse1HmziXwc84dTN7/OMiWefZM8MGrTgwojP/0p7e4JU+PxTcHlS+LzPravtdnZzb7QHX6ttvwoSo+pGexUW5e1y6lqlVSvyMbvC5vmqr+aeIt7qPjfZKf/fgB4mvm6/iU5d+/T4bqMb/D7FS8NOderqjwz2a1ZcXzfe+K0EAMATki4AAJ5UyuHl4ly34lgTN3xtnok5scQQIOiAAAAgAElEQVS/unPtv/ozm1s6dR2qrjBx96p2aPizju8U84xVI9Y8s6WZiR//sI9T1+ae6SZWuxlS9iHzLbtE74IDBjt1v/z9KRP/e307E78z8kSnXaMRTAkl2qJuu018Z+uL3borDzDxyaf8ZOJHD3SnkTq+eIOJVTF/aFu9usHE9X+bHLlhGcedLgAAnpB0AQDwRGmt990qTnqlnO/vxeD4LPRW3HfqT+b1TGve1MQL/lM7YrsH//Kuib/f1trE4ycc7rRrcVf5Gq5KxPUU4T2aTBXtPVrZRbqe3OkCAOAJSRcAAE9IugAAeMKSIZRLeUuXmbjFRcsithspwaVGdpejFlK+5nABVAzc6QIA4AlJFwAAT0i6AAB4QtIFAMATki4AAJ6QdAEA8ISkCwCAJyRdAAA8IekCAOCJ11OGAACozLjTBQDAE5IuAACekHQBAPCEpBuglNJKqR1KqfujbN9PKbW98HGtE90/lEwM17Nn4fUMKaV6Jrp/KJkYrueQwvZaKcWJamVQZfybS9L9s85a67v3FpRSpyulZhVe6O+VUh321mmtx2itM5PTTUQp/HqeqJT6WSm1VSm1WCnVf2+d1vrzwusZ+axAJFv49eyilJqmlNpZ+L9d9tZpre8VkY5J6SVKwlxTpVR9pdR3SqkNSqnNSqnJSqmj9zasCH9zSbrFUEq1EZFXROQ6EaktIuNF5H0+NZdPSql0ERknIs+KSC0RuVBEHlNKdU5qxxATpVQVEXlPRF4WkToiMlZE3iv8Ocqn7SLyVxHZTwqu6X9FZHxF+ptL0i3eySLyjdb6W611nhT8AjQSkeOT2y3EqK6I1BSRl3SBqSIyR0Q6FP8wlFHdRSRNRIZqrXO01sNFRInIiUntFWKmtd6ttZ6ntQ5JwbXMl4LkWze5PYsfkm7xVOF/4eWDktMdlIbWeq2IvCYiVymlUpVSR4pIMxH5Nrk9Q4w6isgM7W42MEMYUi73lFIzRGS3iLwvIqO11uuS3KW4IekW7zMROV4p1b1wyOouEakiItWT2y2Uwmsi8n8ikiMi34jI3Vrr5cntEmKUKSJbwn62RUSyktAXxJHWupMUjEpdIhXsQzFJtxha67kicoWIjBCR1SJSX0R+E5EVyewXYqOUaicib4hIXyn48NRRRG5XSp2W1I4hVtul4A9zUE0R2ZaEviDOCoeaXxOROyvS9y5IuvugtX5ba32Q1rqeiNwrBcORU5PcLcTmIBGZp7WeoLUOaa3niciHInJqkvuF2MwWkU5KqeAUUKfCn6PiSBeRlsnuRLyQdPdBKXVI4fzfflLwrdfxhXfAKH+mi0ibwmVDSinVSkT6iMivSe4XYjNRCr5oc5NSKkMpdUPhz79MXpdQGkqpI5RSxyilqiilqiml7hCRBiLyY7L7Fi8k3X0bJiKbRWRe4f9ek9zuIFZa60VSsBxhuIhsFZFJIvKOiIxJZr8QG631HhE5SwqmCzZLwbU9q/DnKJ8yRORJEdkgIitFpLeInKa1XpXUXsURpwwFKKV2S8EXbIZrre+Jov1VIvK4iFQVkQ5a68UJ7iJKIIbr2UMKknCGiPTWWn+V4C6iBGK4nveKyC1ScD1raK3zE9xFlFBl/JtL0gUAwBOGlwEA8ISkCwCAJyRdAAA88bqJdK+U85lATpLPQm+pfbcqGa5n8iTieopwTZOJ92jFEul6cqcLAIAnJF0AADwh6QIA4AlJFwAAT0i6AAB4QtIFAMATki4AAJ6QdAEA8ISkCwCAJyRdAAA8IekCAOAJSRcAAE+8HngA+JbWrImJNx/eyMSr++xx2g34yyQTD6oz36k76NurTBxaWsPErYf86rQL7dwZuR8HHmDivNVr9tVtoELJ63GIiTd0zHDqdu1vz2TQrXeY+I7Onzrt+tWy75tPdrrPMXhkPxM3fOj70nU2wbjTBQDAE5IuAACeMLyMCmXV4KOc8t1Xv2biszPXRXxcSuDzZ0hCTt2MY8bYwjE27Lz7Zqdds3sjD2tlvJFv4rzjIjbDXsoeRbpuwJFO1YAb3zVx/1qrYnr6kVsamvjdM44wcWjpCqedznWnIRC9LZfZf9cv/zPcxBnKTTshKfrI3xRxj6PN1bZdj2ruVM63Nz1q4qNSbzVx4wfL3lAzd7oAAHhC0gUAwBOGl8OkdG5v4nm3VDPx5V1+dNrdWHeKiXs8OtipO2Bo2RvSqMhSO2SbODicLBJ5SPmP/Byn/HtedRPnS7pTd2gVO8SYGhj2/PXqYU67blvtcPOBj7q/A8fUXWTiCVKzyD5VeimpJlx+9+EmnnndiIgPydF22H5VnntNqwZGJ/dPre7U9atph5H7TXzbxMM2tXbafdHnIBPnLV0WsR/4s61nbTdxurLXNnw4eVneLhPfveKMiM/349yW9vlquMP+3x79tImPOsuuKlj+mPstZ53j/o4kA3e6AAB4QtIFAMATki4AAJ5UyjldlWHH+df0P8Sp+/FOO0+3LWTnDY54/Tan3ddd7NzP8ZdNdermDY1LNxGluXdmmjh8Djd4DU/46RoTNxhW1WmXOvHniM+//lq7ZKXPwK9NfFf9X5x2+e70kePbja0CpT8iN6zEVg6Odh43z8SdX7Xz6C1vn+y0S23fxsRz/57l1M068RkTB5ew3FxnoftiH9jw8+4tnKr89Rsi9hEiza9ZaeKBn9h1crM2HuC0qxNYeZc/f5FEki0bI9Yd/szfTDz/dDu/2+XWG512jR9I/vdtuNMFAMATki4AAJ5UmuHllKp2OHHu0E4mXni6O4z1xGY7JPXWkFNM3OrNsKGrbDtcOKNVF6dOn27XKqTttEsa0r6YVtJuIwr/O/bpQMn9HDnwd7sEoeHZv8X0/PWftdf+y3V2S6q7RvxSVPMizfvE/l41ZnhZRERUmvvnp8rR0Q3XHvQ/O2TYJmxIOSh/zgLbrq9bd2x/O6b50B0jTdy9aq7TLjjc/EXWwe6TMLxcrPxNm0w8fZSdoqm9yF22kz8/8tROtFJ3FH3/2LH3PKe85YFSv1SpcacLAIAnJF0AADwh6QIA4EmFndNNqe5u+7by1WYmXtjNLhd4bFMbp92EG483ceZXP0R8/uBX26tv2urUDZo80cSj19ivym/5Yh+dRkwOrmK3bQzfYm7qfLvMI1tKPweXNcvOx3672112VG92XnhzQ6uIVZVWatPGTnnqIa8V2e6JzS2dcrtn7FxhfnjjKNUfaeeCx11zqIm7N4w8R4zY1RudnH/XPvV/dcqvSOMILf3hThcAAE9IugAAeFKhhpeDQ8pzHz3IqQsOKT+ysa2Jvz6jg9MudUnJv76+/Ep3iLpHtQkm3riffb4Xa3dy2uVv3lLi18KfnTDrXBN/dtCbTt3Y7qNNfL+4S7uildfD7lq23312WqFlmnv96t+6xMQ73nOfQxV9TneltvTChhHrtmu7rOT1B05x6mr9FnnaJxaLr2xu4u/Gu6eJHZ0RMvGC/m5/W95jd1zSeZGnFhB/Oad2c8pX9ppYZLt313UN+0nyl+txpwsAgCckXQAAPKlQw8t/XNrZxAvPeNKp+3Cn3RT/6zM7mjhvydJSv+6eWpHHDufstkNSDCcnRuYg+2v89NvuUH//WvNNPP+pw0zc4b+rnXZrT7Lfajz9hklOXd/a9hCMhmnBUw3cEw5ebDnexH16uxut51VjfFlEJLVeXRPfccWbEdu9vc1+67zWK/EdTg6XP9vuWnTFhP5O3cIz7LTUnL7u35TT3glsc/XTrMR0rhJLrVnTKa+92P7dvnaQO3/Tr+YKEy/N22XiDQ+7h1RUZXgZAIDKg6QLAIAnJF0AADwp13O6aY3cr/DfPvhVE6/M3+nUPXjvQBPXXFz6OaK0ls1N3OfUHyM3RMIFT5N5adipTt2Ae23d3DMDc3Jnus+REvj8GZKQWylFn05/x5ojnfL4r+3ORu1mrnDqrn3InnA04R53rqoyUYHTvi7NWpfEnhSt5tywP4lnFN1ORGTedfb/S/bVCepQBZTSxV2muap7bRNvbWuXXl1ztPvdisH1virmWe2Wbz0/usXE2eOnxNjLxOFOFwAAT0i6AAB4Uq6Hl0P13GG6c2vYjdD/tf5wp67mqyUfUg4esr1y0GFO3Z3XvGHiizKT/zX0ymzXmfbaHHvt1Lg/f7/fe5n4j1uamjhlxkKnXeud9neM/YlK56tN7QKlzUnrB6KXduABTvmKSfaQg5OrrzFxurhDvukqtdSvfcxtdvow+434/w2IJ+50AQDwhKQLAIAn5Xp4uThn1JzulD/of7OJ03dG3h1o42l2N5MPjnrKxK3S3CGRd3fYb9y1fv86py64i83Ujc0CNauK7zSitvEq+83hC2791MSD6swPaxnd58rgEFeHJ93dpJrc/32gZIc6w7/jXJwUVZLWFdfiq5tH1W7W6/Ybrg3k+2JaoqzQddzpvrNrbAyUqiT0tZ0DRUKxnrLsB3e6AAB4QtIFAMATki4AAJ6U6znd0Mx5Tjn7Tfu18fkXPOXUTbnXPSEkGp/sqmfis0b/1alr+tA0E7dru9V9YGAXmwVT7ZxuS+Z0Y5bWrIlTvueusSY+tfo2E4fvJrUx3x6GfsYMew1fPOgFp13rdLvrVNruUnW1SCHN51sRkd3N9iS7C0iU1e7SycOnXWLirvuvNPE3Xx7stKu2VklRdjVwv3vzr3NfN/G5meudut53TTTxR9LdxFmvJ/aEqljwlwAAAE9IugAAeFKuh5dFu8MPrf9mhxIOm3u9UxfqvUmKsnldllNu/o6Nq3xidzZpErZsIfjKesZcp+7f6w8y8WUn2027v789sV+br2hS27Y28YMTXnbq2qbbJT7L8uwQcu+XBzvtWj/1u4nrrrTLifq85P5+zD1xtG13ctg0wOOBHXNiXI4w5tVTTNyYJTCogPI3uX9j9zvDloPHf7SQyRKLl56wuww+8Xx1p+7Lg+0OgZOuaWMr3gzb7aoMLCfiThcAAE9IugAAeELSBQDAk/I9p1uM+s+GzRs8W3S7/ePwWqn16jrlrtXt3PK0nS3i8AqV04J7M00cnMMVEfl8l52L/+f9N5m4+fPudY902k/ry91tQs+ddJqJJ3R8y6k7YqDdQnT/EbHNxzZ+gHncfVmdv9PENZeV/XOaaizkOxo+5a22JxVlnuLW3Tr1GBN/1O5dEx9xzQ1Ouz/lhSTgThcAAE9IugAAeFJhh5d90o3cQerTqm838c3f2NNwsuUnb32qCF444rmIdQ/ffLmJ635Y+iGjRZ+0tAV3REquHjjexO+PqCdIjKwUO4WQU9PG1RL8uqnt7RKTy66ZEPXjmo1dbOKyPxgeH6l16jhlvcfuMBbascN3d4xPvu5q4scvslM5Z1//ldPum2ereutTJNzpAgDgCUkXAABPGF6Og5W96kasS1uf7rEnFUtqYN+vlLDPhxkbcsKbl0rzF+xQ4ct93cMVjq620MQf1s82cf76DXHtQ2WQNTvwjd+T3bpMZQ+dOPJmuxvcnBcT26dGL9gdyG6psyBiu/Zj3V3MWv4xNULLiiWtSWMTd3hvpVP3wXt2+qzpkMR+Q19l2N+PZYMPcepu7/1uePOCPlVZH/aTxkW284k7XQAAPCHpAgDgCUkXAABPmNONg5w6et+NUGIvbzjKxF0bfuvULf2bjVs+2MHEoV9+i+m1dJ49fWRLvnuCSfsq9rPpurPtnG69UdEvVdp20REmLosHa/vS5PWltnBL5HYHV7fn0syRA+Lej8X/sXORbzZ6LFCT4bQbtcXO77d+fKFTl59XORYKbTmskYn/0+B9p+6uq78z8SH1/+bUtR29tcSvtfj82ibOrRNy6u7r+baJL8h0549TRJk4+Kin7jvPaVdLkv/e404XAABPSLoAAHjC8DLKrE8//4st9HWHl2ccM8bEq96zy4ceXdfDaffxN10lGuPOGWri8MMVpufYz6b7vfKrid3Br+Kd949PTTzh9ZoleGTFogO7Fg3b1Nqpu7mOHb69OGuZie9/sbfTru0j9mCE0Iy5Ub3u9vMPd8rTL3vcxNUCS5WCw8kiIu+fa6c48v+IvJyoIquxcpeJ/73+IKfuH/VnmXjeOU85dSnnBId8g8v/lNMuWOc8Psp2IiLrAodlHP3erSbOfts92KQsTARypwsAgCckXQAAPCHpAgDgCXO6CZCq7GeZOrOT2JFyrvXQRSb+8UJ3O83DM3JN3DjNnkPzaNjSokcvdMuRpIh9/lDYbO3H2zrZup07JRaj5hxt4qYyM6bnqAjyN28x8Rd93PlB+cCGwfndBT1GO81eOswuIfrv6+6SkKBLz/nSxrUedeqqqerhzUVE5ImXz3TKjeckdmvDcuGHGSb8+pYjnaqT/m7n5f/X7g2nLritZ/j8bJC73MfOur6yzT297bxMu11nx08GOnXNxtnnaPPhjyYuC3O44bjTBQDAE5IuAACeMLycAPnaDk/WmbO9mJYoTv7adSb+zynnOnXzBu5n4v49vjDxoLqx7UjVb9kJJp46wR32bDlmWaC0QmLR9PzKO6QcSd7SZU751WGBY4duDoR13J2gLs9aY+NrRkT5au5w8gtbG5r4nfOON3HjOT8KIkv7Ypr7A/vWkzNOv9mpWnWxPeB+yrF2OdF58y5y2q3/wJ78owIzOw1fcZeDje1sh/6zv/wp6j6XNdzpAgDgCUkXAABPGF5OgOC3lxEf+fMXOeXWg2z5S6kRiLvF+Ap2c/am4n5jtXJsa598wQMkPn2hvok/b97FaTf3Bvut1mMOs9MJ307pIJG0G7nJKYfmLzGxzp1X8s7iT6qOn+KUW4638UVid/ZKE3da4YCw8l75YeW0LzeWqn9lBdkBAABPSLoAAHhC0gUAwBPmdBNgUa5dJpS62e5gFD5HAaBoOtcuN8lfsNipa3OzLa8N/ryYA8p576Gs4E4XAABPSLoAAHjC8HIcNP/HZKc88B/HBEruUhcAQOXFnS4AAJ6QdAEA8ISkCwCAJyRdAAA8IekCAOAJSRcAAE+U1jrZfQAAoFLgThcAAE9IugAAeELSBQDAE5IuAACekHQDlFJaKbVDKXV/lO37KaW2Fz6udaL7h5LhelYsXM+KJ4ZrOqSwvVZKlcuzA/j2coBSSotIG631wsDPRorI8SLSRkT+qrV+IZrHIfnCr4tSKltEHhaRo0QkVUSmishNWut5xT0OZUMR1/NYEfk4rFkNETlPa/1OpMeh7IjwN7eLiIwRkfYiMkdE+mmtfwnUNxeRJSKSrrXO89rhOOBOd99+FZGBIvJzsjuCUqstIu+LSFsRaSAiU0TkvaT2CDHTWn+jtc7c+5+I9BGR7SLySZK7hhgppapIwXvyZRGpIyJjReS9wp9XCCTdfdBaP6m1/kJEdie7LygdrfUUrfUYrfVGrXWuiDwuIm2VUvWS3TfExRUi8rbWekeyO4KYdZeCI2eHaq1ztNbDRUSJyIlJ7VUckXRRmR0nImu01huS3RGUjlKquoicJwV3Rii/OorIDO3Oe84o/HmFQNJFpaSUaiwiT4rILcnuC+LiXBFZLyKTkt0RlEqmiGwJ+9kWEclKQl8SgqSLSkcptZ+IfCoiT2mtX0t2fxAXV4jIi5pvhpZ320WkZtjPaorItiT0JSFIuqhUlFJ1pCDhvq+1jmqZAso2pVQTKZgLfDHJXUHpzRaRTkopFfhZp8KfVwgk3X1QSlVRSlWVgsn8dKVUVaUU/27lkFKqpohMEJHvtNZ3Jrs/iJvLReR7rfWiZHcEpTZRRPJF5CalVIZS6obCn3+ZvC7FF8lj3z4VkV1SsLZzZGF8XFJ7hFidLSLdROSqwk0T9v7XNNkdQ6n0Fb5AVSForfeIyFlScE03i8hfReSswp9XCCRdV46ITFNK3bf3B1rr7lprFfbfRBERpdRVSqnNhY8LJafLKIZzPbXWYwuvX43g+k6t9TIRrmc58Kf3p4iI1rqd1npMeGOuZ7lQ1N/c6VrrQ7TW1bTWf9FaT99bp5S6Vwr2TsgRkXI5f8+OVAAAeMKdLgAAnpB0AQDwxOspDb1SzmcsO0k+C72l9t2qZLieyZOI6ynCNU0m3qMVS6TryZ0uAACekHQBAPCEpAsAgCckXQAAPCHpAgDgCUkXAABPSLoAAHhC0gUAwBOSLgAAnpB0AQDwhKQLAIAnJF0AADwh6QIA4InXU4bKmwVj/2LieT1HOXUn3jDQxNXH/eitTwBQGaR2bOuUl55Tz8SH9p7l1L3Y7GsT5+r8qJ6/x/UDnHK1d6eUtIsx4U4XAABPSLoAAHjC8HJxtD2DOCQhp2plDxu3GeerQ9grrUUzEy8/u5GJt2XnOe3aZq808fi275s4+4PrnHaNJ9jPnzWnr3Hq9PadJs7/4w8TqzT37bPqpsNMnFfN7W/TR6bZ58vJEQB/tvWSI0x82p0Tnbpx9WZGfFyutu/f8L/VkTw9dJhTHjyvr4nz5yyI6jliwZ0uAACekHQBAPCE4eUYtWq/ysQqI8OpY/gw/tYMOsop/zT4CRNHO5wUbDW/zzNuXZ/Iz/HGtgNN/NzfzjbxqmPdt8/MK9zhqqDTJ15jYvXdL/vqKlBhpVSt6pQX/bOriWdfPsLE0b6vY5WdXsUpz7m5jq27Lrx1/HCnCwCAJyRdAAA8IekCAOAJc7ox+qjduyY+M7OXU5fPnG5cpLZuYeKxNz8eVlvyX91x2/c38bmZ66N+3IVZq208+ikTp4R9Zg3OQE3PcetSt+wusl1ls/YmOze/9dDdxbRMrPQMu7Rs1jHPR2zXp9EhPrpT8Sm7/DI4hysiMvPy4YFS6e8DO7x5Y8S63y54ImLdgye8ZeLnD+tjK6ZEXqoUC+50AQDwhKQLAIAnDC+jzFrV2y7VaV8l8ufDE2deaOIa99WM2C599WYTj2lY26nLqWeXDwx86C2n7uzMdfvurIjM2qNNPPjWgU5d9VkciiEisuMIu7vXnONHRWwXHLqPdelItM8RrHl5a5OYXgt/FjrWDiMv7m9//tuJw4to/Wdvbz/AKf/jW7tcr8n77t+Dau/Zwwpayw8mVl07uk96QeTXC77Ph7esYeKsOJ+DwJ0uAACekHQBAPCEpAsAgCfM6aLMOubyaRHrVufvMvHamQ1MnHpq5Odr8JOdt117aKr7Wj3tsoBo53DDfbC1i4mrj2MOtyhtBi4x8TlZZzt1S65sauKcOnamVWmJSaj+HhPP6flsxHbtPrLz7+1vXxhWuym2F6+MAsuCRMLncUdG9RSnzzvDxKF79nPqsr/7Kfa+lSHc6QIA4AlJFwAATxheRpn14U+dTfzQ6d84dU3TMk0855IREpWrbJiu3OHlXJ0fKLmfRdcHhrKPfes2E088/xGn3V317RB19wuud+oy3/xBIJK/eYstBGMRaXLfiri+1vYL7IHo0tOtW5hrd6Rq//BG279NDCeXRPDEoPCdpqJdGvRjTrqJ9YkrTaxkZVHNyz3udAEA8ISkCwCAJwwvo8zKHmC3gvlLvX5O3cyjXzBxLDsW5YZ9I/b9HfYA62FLejh1KcPqm7jVR3aY+Ngatzjt5p7+pIlX9cp36rLfLHEXUUqr++yJWDdkhd3QPn/+Ih/dqZB0+1Ymdg8uiKz9F9c65VYj7fs3RX6JT8fKMO50AQDwhKQLAIAnJF0AADxhThflQssh7vxc947XR2gZm9o/rTFxtcVLwmrDy/t2cPZyp5wTS6dQKgt6jDZxKOz+YtqUNiZuLRu89amiWdmjlolTirmHG7ejronbjMh1K+N8SHxxgn3887JBG2t3c6049wEAAHhB0gUAwBOGl1Eu5M+e55QzZ8f3+fP23eRP2mZH3jFn5nz3MPRsWROhJRIlJDoQu8vKYj1EobJLa9LYKZ9yyWQTF7d0744vLzRx9pQ4nwpfjBX3uOVgH8OXDV6x1G5bVufD30zsLv4rPe50AQDwhKQLAIAnDC8XJzAGFf7NvPBvvqFyyO15iIkntHXPCJ0c2Li97VM7nTpGMxNv15mHhf0k8nnM+XXtN2gXv2rPQT6k2TKn3aADP7OPEfcrrdc8d4OJm/z7+5J0tdzaeKw7vPzvBuMitu016wITt799ronjPVwbbukbnUz8XJcXon7comfambj21snFtCwd7nQBAPCEpAsAgCckXQAAPGFOtziBbUnCvw4f/Lr5nAdaOXXZ124UVBwpWVkmfmCknccNn9f/erudE9LT47ymqQJKbbC/U952VAsT76pr7wdSzlkf1fON7Tg07CcZEdvOPemZqJ6z3++9TDztkw5OXfPH7Ik4JT/nqnzacMbOfTcqtHxFPRNnby35rm6xur3TpyY+NCPyDHK/ZSc45XqfLDRxIuedudMFAMATki4AAJ4wvBwPVSrL4FLlkFqvrlPe/qrd1L1rRuQdbZ6bdLyJ28iPielcOZd70qEmzrpnqVM3ruUIEweX6BW305Erfd9NCgWHjf+4pWnkhj/MMGFTcZcFVcZ3/V1dPnHKxR1ykN3vp0R3x9j6sZ3i61szuFQscv9+e66jU673R+KWCQVxpwsAgCckXQAAPCHpAgDgCXO6QJjl/do55Z8OGlZku3+v7+SU2z++1sSxnFpUGfx+qv2TM6HlBKfulW2NTLw5v7qJ31vV2Wm37qtGUpTh/Z51yj2q2YUf3X6+2Kmr22d+oLS5+E7DyNfufVr08+2ll1rbfrdi4TPNnLrZnZ6Pqk8d3rzRxK1H+ZnDDcedLgAAnpB0AQDwhOFlVErBXaZERNa+0tDE73R+OKx1FRMN32SHnic8dKzTqtbiH+LXwQqq9hy7y1v2R9c5de0H2yHf/M1bTFxFfnfaNQ4r7/XrJe6Q43FVF8TcTyRf8EQvEZEG99nrOa7pmLDWRd8/fr7LfZ+3HWV3C0z0aUeRcKcLAIAnJF0AADxheBll1ppBR5m4Sk930/tHO7xp4pCO7rPj/UtPM/GQFu86dcGdpoLDyeG+uryOiFwAAAQBSURBVNDuqFRrNsPJJVV/5ORA7NYlcrgv/eW6+26EuNpw9ZEmrjc6um8Kz3/eDik3a7TBqRvV9IsS9+HGj69wym1+S/5OcdzpAgDgCUkXAABPSLoAAHjCnC7KjG0XHuGUfxr8RMS2wQPkc3VuVM//UTs7jxt+AH3wxKAtod1OXY9HBpv4gNnuSTNIrtQG+5u4YXrRS4lERNJ2V8YzgeLvoRknOeW+xzwfoaVIh36zTfzTgfb7Gf0v+shpd33tRSZOV7+YOFeHz/JHvkcMvp+zx95g4jZ/T86uU8XhThcAAE9IugAAeMLwchiVZv9JMmrsSWJPKp/VvdxjAorbuDw4HBzLpuvhB9AHn+P/1vRw6hp9+oeJk7WLDYq27agWJj4788OwWu4p4q3xyHSnPLmbHdY9PMOd5nGW+FwXeblP8N0b7fs6uDOciMio8XbYu+U/fzZx2Nu8TOC3EgAAT0i6AAB4QtIFAMAT5nTDpLRoauJfjnouYrvgspKGH/HPGKvUenZ7vosPmZLEnliPN/zGKX81PtPETxzT3cR5a9YKyo6UsHuI4Hs0bTuz8fGQ9sU0p3zbkAEm/uaB4XF9rRV5OU75obW9TLz8yiZOXYvf7NKgsjiPG8SdLgAAnpB0AQDwhHHRcBs3m/DgF28y8aHHzXWarXi4jYkz303+yRXlVW4He/D4vftPiPvzn/LbeSZeO6mRrVBuuzsvtacWXZi12qk7odp2Ez+REfkEIiRX+BKTF7ccbOL0z6eFN0cc1P/E7ibVtcnNTt30AcNK9dxnD7vdKR/4WHA3uPmleu5k4k4XAABPSLoAAHjC8HKY/A0bTdwisFn2hrB21aRsfNO2vEtfbYfzj5l+qVP3bddXIj5udf4uE/d6yR5I0HrkCqddxio7VNwkN/KG+K8/09XEb1Q/0qnbekhDE2dtLb/DWpXNqDlHm7ipzExiTyqu/LXrTNzk3+ucujP+3a1Uz32gVMzDRbjTBQDAE5IuAACekHQBAPCEOV0kVf7CJSau28etO0OimxNqLnbuPa+YdsX2448/ItZV/325bRfj8yMxVvaMXJf5UWbkSiBJuNMFAMATki4AAJ4wvAyg3ErZbbcWe3TDQU5d3ecnhzcHko47XQAAPCHpAgDgCUkXAABPmNMFUG61uvUHE0+SaknsCRAd7nQBAPCEpAsAgCdKa53sPgAAUClwpwsAgCckXQAAPCHpAgDgCUkXAABPSLoAAHhC0gUAwBOSLgAAnpB0AQDwhKQLAIAnJF0AADwh6QIA4AlJFwAAT0i6AAB4QtIFAMATki4AAJ6QdAEA8ISkCwCAJyRdAAA8IekCAOAJSRcAAE9IugAAeELSBQDAE5IuAACe/D8gDsctzBrBmwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8, 8))\n",
    "\n",
    "for idx in range(16):\n",
    "    plt.subplot(4, 4, idx + 1)\n",
    "    plt.axis(\"off\")\n",
    "    plt.title(\"[{}]\".format(np.argmax(mnist.train.labels[idx])))\n",
    "    plt.imshow(mnist.train.images[idx].reshape([28, 28]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = tf.placeholder(\"float\", [None, 784], name='x')\n",
    "y = tf.placeholder(\"float\", [None, 10], name='y')\n",
    "\n",
    "#卷积网络的输入是图片，因此需要对输入x作reshape\n",
    "x_image = tf.reshape(x, [-1, 28, 28, 1]) #-1表示自动计算图片个数，对应None对应batch_size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#help(tf.ConfigProto.gpu_options)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /home/kite/anaconda3/lib/python3.7/site-packages/tensorflow/python/framework/op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n",
      "WARNING:tensorflow:From /home/kite/anaconda3/lib/python3.7/site-packages/tensorflow/contrib/layers/python/layers/layers.py:1624: flatten (from tensorflow.python.layers.core) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use keras.layers.flatten instead.\n"
     ]
    }
   ],
   "source": [
    "#1st layer:convolution\n",
    "with tf.name_scope(\"conv1\"):\n",
    "    C1 = tf.contrib.slim.conv2d(\n",
    "    x_image, 6, [5, 5], padding=\"valid\", activation_fn=tf.nn.relu)\n",
    "    \n",
    "#2nd layer:pooling\n",
    "with tf.name_scope(\"pool1\"):\n",
    "    P2 = tf.contrib.slim.max_pool2d(\n",
    "    C1, [2,2], stride=[2, 2], padding=\"valid\")\n",
    "    \n",
    "#3rd layer:convolution\n",
    "with tf.name_scope(\"conv2\"):\n",
    "    C3 = tf.contrib.slim.conv2d(\n",
    "    P2, 16, [5, 5], padding=\"valid\", activation_fn=tf.nn.relu)\n",
    "    \n",
    "#4th layer:pooling\n",
    "with tf.name_scope(\"pool2\"):\n",
    "    P4 = tf.contrib.slim.max_pool2d(\n",
    "    C3, [2, 2], stride=[2, 2], padding=\"valid\")\n",
    "    \n",
    "#将池化后的3维数据展开为1维数据，方便输入下面的全连接网络层\n",
    "P4_flat = tf.contrib.slim.flatten(P4)\n",
    "\n",
    "#5th layer:full connection\n",
    "with tf.name_scope(\"fc1\"):\n",
    "    F5 = tf.contrib.slim.fully_connected(\n",
    "    P4_flat, 120, activation_fn=tf.nn.relu)\n",
    "    \n",
    "#6th layer:full connection\n",
    "with tf.name_scope(\"fc2\"):\n",
    "    F6 = tf.contrib.slim.fully_connected(\n",
    "    F5, 84, activation_fn=tf.nn.relu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#添加0.4的dropout，保留率keep_prob = 0.6, 丢弃率rate = 1 - keep_prob = 0.4, 以提高网络的推广能力，减少过拟合的可能性。\n",
    "#注意，dropout仅在训练模型时使用，在验证或测试模型性能时，dropout应该关闭。\n",
    "#dropout后的输出最后输送至输出层，即分类器， 一个神经元个数为10的全连接层。\n",
    "with tf.name_scope(\"Dropout\"):\n",
    "    keep_prob = tf.placeholder(tf.float32, name=\"keep_prob\")\n",
    "    F6_keep = tf.nn.dropout(F6, rate=1-keep_prob)\n",
    "\n",
    "#7th layer:full connection(output layer)\n",
    "with tf.name_scope(\"fc3\"):\n",
    "    F7 = tf.contrib.slim.fully_connected(\n",
    "    F6_keep, 10, activation_fn=None)\n",
    "    \n",
    "#注意这里最后一层没有加激活函数，F7是未经激活的输出logits    \n",
    "logits = F7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Conv/weights:0\n",
      "INFO:tensorflow:Summary name Conv/weights:0 is illegal; using Conv/weights_0 instead.\n",
      "Conv/biases:0\n",
      "INFO:tensorflow:Summary name Conv/biases:0 is illegal; using Conv/biases_0 instead.\n",
      "Conv_1/weights:0\n",
      "INFO:tensorflow:Summary name Conv_1/weights:0 is illegal; using Conv_1/weights_0 instead.\n",
      "Conv_1/biases:0\n",
      "INFO:tensorflow:Summary name Conv_1/biases:0 is illegal; using Conv_1/biases_0 instead.\n",
      "fully_connected/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected/weights:0 is illegal; using fully_connected/weights_0 instead.\n",
      "fully_connected/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected/biases:0 is illegal; using fully_connected/biases_0 instead.\n",
      "fully_connected_1/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected_1/weights:0 is illegal; using fully_connected_1/weights_0 instead.\n",
      "fully_connected_1/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected_1/biases:0 is illegal; using fully_connected_1/biases_0 instead.\n",
      "fully_connected_2/weights:0\n",
      "INFO:tensorflow:Summary name fully_connected_2/weights:0 is illegal; using fully_connected_2/weights_0 instead.\n",
      "fully_connected_2/biases:0\n",
      "INFO:tensorflow:Summary name fully_connected_2/biases:0 is illegal; using fully_connected_2/biases_0 instead.\n"
     ]
    }
   ],
   "source": [
    "cross_entropy_loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(labels=y, logits=logits))\n",
    "l2_loss = tf.add_n([tf.nn.l2_loss(w) \n",
    "                    for w in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)])\n",
    "\n",
    "for w in tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES): #TRAINABLE_VARIABLES为用于训练优化器的变量子集\n",
    "    print(w.name)\n",
    "    tf.summary.histogram(w.name, w)\n",
    "    \n",
    "total_loss = cross_entropy_loss + 7e-5 * l2_loss\n",
    "\n",
    "\n",
    "tf.summary.scalar(name=\"cross_entropy_loss\", tensor=cross_entropy_loss) #scalar value：标量。name为已生成的节点node，tensor为一个单值的实数tensor\n",
    "tf.summary.scalar(\"l2_loss\", l2_loss)\n",
    "tf.summary.scalar(\"total_loss\", total_loss)\n",
    "\n",
    "optimizer =tf.train.GradientDescentOptimizer(learning_rate=0.3).minimize(total_loss)\n",
    "\n",
    "pred_prob = tf.nn.softmax(logits)\n",
    "correct_pred = tf.equal(tf.argmax(y, axis=1), tf.argmax(pred_prob, axis=1))\n",
    "accuracy = tf.reduce_mean(tf.cast(correct_pred, dtype=tf.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 64\n",
    "step = 1100\n",
    "#batch_size * step = 11000 = train集样本数(5000) * 2 = 2 * epoch\n",
    "#所以设置step = 1100时，相当于运行了两次整个训练集\n",
    "\n",
    "#Saver用于保存或恢复模型\n",
    "saver = tf.train.Saver()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "After [100] steps: The total loss is 0.641049325466156. The accuracy on validation set is 0.9223999977111816\n",
      "After [200] steps: The total loss is 0.4195956289768219. The accuracy on validation set is 0.9557999968528748\n",
      "After [300] steps: The total loss is 0.12326377630233765. The accuracy on validation set is 0.9557999968528748\n",
      "After [400] steps: The total loss is 0.08049999177455902. The accuracy on validation set is 0.9703999757766724\n",
      "After [500] steps: The total loss is 0.09835777431726456. The accuracy on validation set is 0.9746000170707703\n",
      "After [600] steps: The total loss is 0.1216772049665451. The accuracy on validation set is 0.9718000292778015\n",
      "WARNING:tensorflow:From /home/kite/anaconda3/lib/python3.7/site-packages/tensorflow/python/training/saver.py:966: remove_checkpoint (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use standard file APIs to delete files with this prefix.\n",
      "After [700] steps: The total loss is 0.13825851678848267. The accuracy on validation set is 0.9768000245094299\n",
      "After [800] steps: The total loss is 0.10346078127622604. The accuracy on validation set is 0.9746000170707703\n",
      "After [900] steps: The total loss is 0.05548684671521187. The accuracy on validation set is 0.979200005531311\n",
      "After [1000] steps: The total loss is 0.0300914254039526. The accuracy on validation set is 0.9797999858856201\n",
      "After [1100] steps: The total loss is 0.024076886475086212. The accuracy on validation set is 0.9829999804496765\n",
      "\n",
      "The trainning is done!\n",
      "\n",
      "The accuracy on test set is 0.9837999939918518\n"
     ]
    }
   ],
   "source": [
    "config = tf.ConfigProto()\n",
    "config.gpu_options.allow_growth = True\n",
    "#config.gpu_options.per_process_gpu_memory_fraction = 0.4  #占用40%显存\n",
    "\n",
    "merged = tf.summary.merge_all()  # 用于将所有summary全部保存到磁盘，以便tensorboard显示\n",
    "with tf.Session(config=config) as sess:\n",
    "    writer = tf.summary.FileWriter(\"./logs/\", sess.graph)  # 指定一个文件用来保存图\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "\n",
    "    # 定义验证集和测试集\n",
    "    validation_data = {\n",
    "        x: mnist.validation.images,\n",
    "        y: mnist.validation.labels,\n",
    "        keep_prob: 1.0\n",
    "    }\n",
    "    test_data = {\n",
    "        x: mnist.test.images,\n",
    "        y: mnist.test.labels,\n",
    "        keep_prob: 1.0\n",
    "    }\n",
    "\n",
    "    for i in range(step):\n",
    "        xs, ys = mnist.train.next_batch(batch_size)\n",
    "        _, loss, rs = sess.run(\n",
    "            [optimizer, total_loss, merged], feed_dict={\n",
    "                x: xs, y: ys, keep_prob: 0.6}\n",
    "        )\n",
    "        writer.add_summary(rs, i)  # 调用其add_summary方法将训练过程数据保存在filewriter指定的文件中\n",
    "\n",
    "        if i > 0 and (i+1) % 100 == 0:\n",
    "            validation_accuracy = sess.run(accuracy, feed_dict=validation_data)\n",
    "            print(\"After [{}] steps: The total loss is {}. The accuracy on validation set is {}\".format(\n",
    "                i+1, loss, validation_accuracy))\n",
    "            saver.save(sess, \"./model/model.ckpt\", global_step=i+1)\n",
    "\n",
    "    print(\"\\nThe trainning is done!\\n\")\n",
    "\n",
    "    test_accuracy = sess.run(accuracy, feed_dict=test_data)\n",
    "    print(\"The accuracy on test set is {}\".format(test_accuracy))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /home/kite/anaconda3/lib/python3.7/site-packages/tensorflow/python/training/saver.py:1266: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use standard file APIs to check for files with this prefix.\n",
      "INFO:tensorflow:Restoring parameters from ./model/model.ckpt-1100\n",
      "1.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    ckpt = tf.train.get_checkpoint_state(\"./model/\")\n",
    "    if ckpt and ckpt.model_checkpoint_path:\n",
    "        saver.restore(sess, ckpt.model_checkpoint_path)\n",
    "        final_pred, acc = sess.run(\n",
    "        [pred_prob, accuracy], feed_dict={\n",
    "            x:mnist.test.images[:16],\n",
    "            y:mnist.test.labels[:16],\n",
    "            keep_prob: 1.0\n",
    "        })\n",
    "        orders = np.argsort(final_pred)\n",
    "        plt.figure(figsize=(8,8))\n",
    "        print(acc)\n",
    "        for idx in range(16):\n",
    "            order = orders[idx, :][-1]\n",
    "            prob = final_pred[idx, :][order]\n",
    "            plt.subplot(4, 4, idx + 1)\n",
    "            plt.axis(\"off\")\n",
    "            plt.title(\"{}: [{}]-[{:.1f}%]\".format(np.argmax(mnist.test.labels[idx]), order, prob * 100))\n",
    "            plt.imshow(mnist.test.images[idx].reshape([28, 28]))\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
